<!DOCTYPE html>  
<meta charset="utf-8" />  
<title>WebSocket Test</title>  
<h2>es6</h2>  
<body>
<div id="output">
	1.  var 存在变量的提升、暂时性死区  	
		let和const不存在（在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。）
		let和const 不允许重复定义，为JavaScript 新增了块级作用域。
		const 定义的为常量,一旦声明，常量的值就不能改变。

		const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址不得改动（例：const obj={} obj.a=1）

	2.遍历字符串
		for (let codePoint of 'foo') {
		  	console.log(codePoint)
		}
	3.repeat方法返回一个新字符串，表示将原字符串重复n次。（'na'.repeat('3') // "nanana"）
	4.padStart()用于字符串头部补全，padEnd()用于尾部补全。
	5.模板字符串（var a=1; `${a}2`）
	6.数组合并（// ES5的合并数组 arr1.concat(arr2, arr3);// ES6的合并数组 [...arr1, ...arr2, ...arr3]）
	7.set
	8.promise
	（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成				功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状				态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。

				（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
				(3).Promise 内部的错误不会影响到 Promise 外部的代码，通俗的说法就是“Promise 会吃掉错误”。
	9.形式上，Generator 函数是一个普通函数，但是有两个特征。一是，function关键字与函数名之间有一个星号；二是，函数体内部使用yield表达式，定义不同的内部状态（yield在英语里的意思就是“产出”）。
	  返回一个遍历器对象，代表 Generator 函数的内部指针(Iterator)
	  yield和return区别在于每次遇到yield，函数暂停执行，下一次再从该位置继续向后执行，而return语句不具备位置记忆的功能。
	  Generator函数只有跟上 .next() 才会执行

	10.async和await 
		1.内置执行器。Generator 函数的执行必须靠执行器(next()或者co)，所以才有了co模块，而async函数自带执行器。也就是说，async函数的执行，与普通函数一模一样，只要一行
		2.更好的语义。async和await，比起星号和yield，语义更清楚了。async表示函数里有异步操作，await表示紧跟在后面的表达式需要等待结果。
		3.更广的适用性。co模块约定，yield命令后面只能是 Thunk 函数或Promise对象，而async函数的await命令后面，可以是 Promise 对象和原始类型的值（数值、字符串和布尔值，但这时等同于同步操作）。
		4.返回值是 Promise。async函数的返回值是 Promise 对象，这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。

		async 函数的实现原理，就是将 Generator 函数和自动执行器，包装在一个函数里。
	
	11.class 

	12. {keys, values, entries} = Object; 遍历对象 keys遍历key值 values遍历values entries遍历key和value并以数组形式返回

	13.Object.assign({name:1},{sex:'2'})  Object.assign浅拷贝合并对象

	14.proxy

	15.Number.isInteger()判断是否为整数

	16.Object.is(num1,num2)//判断左右数值且类型是否相等
</div>  
</body>
<script type="text/javascript">
	// set方法 set循环方法  返回的是对象-----------------------------------------------------------------------
	const ary=[1,2,2,3,4,1]
	const set=new Set(ary);
	const array = Array.from(set);//或者const arry=[...set]
	console.log(array)

	let setAry = new Set(['red', 'green', 'blue']);

	for (let item of setAry.keys()) {
	  console.log(item);
	}
	// red
	// green
	// blue

	for (let item of setAry.values()) {
	  console.log(item);
	}
	// red
	// green
	// blue

	for (let item of setAry.entries()) {
	  console.log(item);
	}
	// ["red", "red"]
	// ["green", "green"]
	// ["blue", "blue"]
	
	setAry.forEach((value, key) => console.log(key + ' : ' + value))
	//promise语法----------------------------------------------------------------------------------------------------
	
	const p1 = new Promise(function (resolve, reject) {
	  setTimeout(() => reject(new Error('faill')), 2000)
	})

	const p2 = new Promise(function (resolve, reject) {
	  setTimeout(() => resolve(p1), 1000)
	})

	p2
	  .then(result => console.log(result))
	  .catch(error => console.log(error))

	//Iterator(遍历器) ----------------------------------------------------------------------------------------------
	let it = makeIterator(['a', 'b']);

	function makeIterator(array) {
	  var nextIndex = 0;
	  return {
	    next: function() {
	      return nextIndex < array.length ?
	        {value: array[nextIndex++], done: false} :
	        {value: undefined, done: true};
	    }
	  };
	}

	// console.log(it.next())// { value: "a", done: false }
	// console.log(it.next())// { value: "b", done: false }
	// console.log(it.next())// { value: undefined, done: true }

	let arr = ['a', 'b', 'c'];
	let iter = arr[Symbol.iterator]();
	console.log(iter)
	console.log(iter.next())
	console.log(iter.next())
	console.log(iter.next())
	console.log(iter.next())

	let iterable = {
	  0: 'a',
	  1: 'b',
	  2: 'c',
	  length: 3,
	  [Symbol.iterator]: Array.prototype[Symbol.iterator]
	};
	for (let item of iterable) {
	  console.log(item); // 'a', 'b', 'c' 类似数组的对象调用数组的Symbol.iterator，普通的对象无法部署该方法
	}
	
	// Generator 函数------------------------------------------------------------------------------------
	function* helloWorldGenerator() {
	  yield 'hello';
	  yield 'world';
	  console.log('ni'+(yield ' 好'))
	  return 'ending';
	}

	var hw = helloWorldGenerator();
	
	console.log('hw',hw.next())
	console.log('hw',hw.next())
	console.log('hw',hw.next())
	console.log('hw',hw.next())

	// async和await----------------------------------------------------------------------------------
	async function getStockPriceByName(name) {
	  const symbol = await getStockSymbol(name);
	  const stockPrice = await getStockPrice(symbol);
	  return stockPrice;
	}

	let getStockSymbol=(name)=>{
		return name+'1';
	}

	let getStockPrice=(symbol)=>{
		return symbol+'2';
	}

	getStockPriceByName('goog').then(function (result) {
	  console.log(result);
	});
	//--
	function timeout(ms) {
	  return new Promise((resolve) => {
	    setTimeout(resolve, ms);
	  });
	}

	async function asyncPrint(value, ms) {
	  await timeout(ms);
	  console.log(value);
	}

	asyncPrint('hello world', 50);
	// --
	async function f() {
	  throw new Error('出错了');
	}

	f().then(
	  v => console.log('v',v),
	  e => console.log('e',e)
	)
	// 前面已经说过，await命令后面的Promise对象，运行结果可能是rejected，所以最好把await命令放在try...catch代码块中。
	
	// async function myFunction() {
	//   try {
	//     await somethingThatReturnsAPromise();
	//   } catch (err) {
	//     console.log(err);
	//   }
	// }

	// 另一种写法

	// async function myFunction() {
	//   await somethingThatReturnsAPromise()
	//   .catch(function (err) {
	//     console.log(err);
	//   });
	// }

	// class----------------------------------------------------------------------------------
	
	class Ponit{
		constructor(x,y){
			this.x=x;
			this.y=y;
		}
	}

	const po=new Ponit(1,2)

	

	Object.assign(Ponit.prototype, {
	  toString(){},
	  toValue(){}
	});

	console.log('Ponit',po)

	const af = async ()=>{
		await console.log('aaaaaaaaaaaaaaaaa');
		await console.log('bbbbbbbbbbbbbbb')
	}

	af()
		.then(()=>{
			console.log('ccccccccccccc')
		})


</script>
</html>